// ================================================================================
==
void getHbox(cl_entity_t *pEnt){
    typedef float BoneMatrix_t[MAXSTUDIOBONES][3][4];
    Vector vBBMin = Vector(0,0,0);
    Vector vBBMax = Vector(0,0,0);
    vec3_t delta;
    if(!vPlayers[pEnt->index].gotHbox){
        model_t *pModel = IEngineStudio.SetupPlayerModel(pEnt->index);
        studiohdr_t *pStudioHeader = (studiohdr_t*)IEngineStudio.Mod_Extradata(pModel);
        BoneMatrix_t *pBoneMatrix = (BoneMatrix_t*)IEngineStudio.StudioGetBoneTransform();
        mstudiobbox_t *pHitbox = (mstudiobbox_t*)((byte*)pStudioHeader + pStudioHeader->hitboxindex);
        vBBMin[0] = DotProduct(pHitbox[11].bbmin,(*pBoneMatrix)[pHitbox[11].bone][0]) + (*pBoneMatrix)[pHitbox[11].bone][0][3];
        vBBMin[1] = DotProduct(pHitbox[11].bbmin,(*pBoneMatrix)[pHitbox[11].bone][1]) + (*pBoneMatrix)[pHitbox[11].bone][1][3];
        vBBMin[2] = DotProduct(pHitbox[11].bbmin,(*pBoneMatrix)[pHitbox[11].bone][2]) + (*pBoneMatrix)[pHitbox[11].bone][2][3];
        vBBMax[0] = DotProduct(pHitbox[11].bbmax,(*pBoneMatrix)[pHitbox[11].bone][0]) + (*pBoneMatrix)[pHitbox[11].bone][0][3];
        vBBMax[1] = DotProduct(pHitbox[11].bbmax,(*pBoneMatrix)[pHitbox[11].bone][1]) + (*pBoneMatrix)[pHitbox[11].bone][1][3];
        vBBMax[2] = DotProduct(pHitbox[11].bbmax,(*pBoneMatrix)[pHitbox[11].bone][2]) + (*pBoneMatrix)[pHitbox[11].bone][2][3];
        if(cvar.hpred && (cvar.hbaim || cvar.bnaim)){
            int hist = (pEnt->current_position + HISTORY_MAX - cvar.predback) % HISTORY_MAX;        
            vec3_t from = pEnt->ph[hist].origin,to = pEnt->ph[pEnt->current_position].origin;
            delta[0] = to[0] - from[0];
            delta[1] = to[1] - from[1];
            delta[2] = to[2] - from[2];
            delta[0] *= cvar.predahead;
            delta[1] *= cvar.predahead;
            delta[2] *= cvar.predahead;
        }else{
            delta[0] = 0;
            delta[1] = 0;
            delta[2] = 0;
        }
        vPlayers[pEnt->index].vPlayerHead[0] = ((vBBMax[0] + vBBMin[0]) * 0.5f) + delta[0];
        vPlayers[pEnt->index].vPlayerHead[1] = ((vBBMax[1] + vBBMin[1]) * 0.5f) + delta[1];
        vPlayers[pEnt->index].vPlayerHead[2] = (((vBBMax[2] + vBBMin[2]) * 0.5f) + delta[2]) + cvar.x;
        vPlayers[pEnt->index].gotHbox = true;
        vPlayers[pEnt->index].vPlayerHead - vPlayers[pEnt->index].getEnt()->origin;
    }
}
// ================================================================================
==
void getBone(cl_entity_t *pEnt){
    typedef float BoneMatrix_t[MAXSTUDIOBONES][3][4];
    if(!vPlayers[pEnt->index].gotBone){
        vec3_t delta;
        BoneMatrix_t *pBoneMatrix = (BoneMatrix_t*)IEngineStudio.StudioGetBoneTransform();
        if(cvar.hpred && (cvar.hbaim || cvar.bnaim)){
            int hist = (pEnt->current_position + HISTORY_MAX - cvar.predback) % HISTORY_MAX;        
            vec3_t from = pEnt->ph[hist].origin,to = pEnt->ph[pEnt->current_position].origin;
            delta[0] = to[0] - from[0];
            delta[1] = to[1] - from[1];
            delta[2] = to[2] - from[2];
            delta[0] *= cvar.predahead;
            delta[1] *= cvar.predahead;
            delta[2] *= cvar.predahead;
        }else{
            delta[0] = 0;
            delta[1] = 0;
            delta[2] = 0;
        }
        vPlayers[pEnt->index].vPlayerHead[0] = ((*pBoneMatrix)[8][0][3]) + delta[0];
        vPlayers[pEnt->index].vPlayerHead[1] = ((*pBoneMatrix)[8][1][3]) + delta[1];
        vPlayers[pEnt->index].vPlayerHead[2] = (((*pBoneMatrix)[8][2][3]) + delta[2]) + cvar.x;
        vPlayers[pEnt->index].gotBone = true;
    }
}
// ================================================================================
==
void StudioDynamicLight(cl_entity_s *ent,alight_s *plight){
    ent = pstudio->GetCurrentEntity();
    if(ent && ent->player){
        if(cvar.bnaim)
            getBone(ent);
        if(cvar.hbaim)
            getHbox(ent);
    }
    IEngineStudio.StudioDynamicLight(ent,plight);
}

Client.cpp in OnlyHook find memcpy(&IEngineStudio,pstudio,sizeof(engine_studio_api_t)); and add this under it
CODE
pstudio->StudioDynamicLight = StudioDynamicLight;

Client.cpp in PreV_CalcRefdef, add inside for loop
CODE

vPlayers[ax].gotBone = false;
vPlayers[ax].gotHbox = false;

Client.h inside PlayerInfo class
CODE
Vector vPlayerHead;
bool gotBone,gotHbox;

Aimbot.cpp, replace/comment out as necessary
CODE
// ================================================================================
===
void targetSpot(float *out){
    vec3_t vecEnd,up,right,forward,EntViewOrg,pAngles;
    cl_entity_s* ent = vPlayers[target].getEnt();
    predictTarget(target,out);
    pAngles = ent->angles;
    gEngfuncs.pfnAngleVectors(pAngles,forward,right,up);
    float h = 0,r = 0,f = 0;
    if(ent->curstate.usehull == 0 && stand.size()){
        f = stand[0].f;
        h = stand[0].h;
        r = stand[0].r;
    }else if(ent->curstate.usehull != 0 && duck.size()){
        f = duck[0].f;
        h = duck[0].h;
        r = duck[0].r;
    }
    if(ent->curstate.gaitsequence == 6 && jump.size()){
        f = jump[0].f;
        h = jump[0].h;
        r = jump[0].r;
    }
    out[0] = out[0] + forward[0] * f + up[0] * h + right[0] * r;
    out[1] = out[1] + forward[1] * f + up[1] * h + right[1] * r;
    out[2] = out[2] + forward[2] * f + up[2] * h + right[2] * r;
}
// ================================================================================
===
void calcViewAngles(){
    float aimSpot[3],org[3];
    if(cvar.bnaim && vPlayers[target].gotBone || cvar.hbaim && vPlayers[target].gotHbox){
        VectorCopy(vPlayers[target].vPlayerHead,org);
    }else{
        targetSpot(org);
    }
    aimSpot[0] = org[0] - me.pmEyePos[0];
    aimSpot[1] = org[1] - me.pmEyePos[1];
    aimSpot[2] = org[2] - me.pmEyePos[2];
    vectorAngles(aimSpot,viewAngles);
    viewAngles[0] *= -1;
    if(viewAngles[0] > 180)
        viewAngles[0] -= 360;
    if(viewAngles[1] > 180)
        viewAngles[1] -= 360;
}

Register your cvars, you will need to change alot to get it working with standard OGC compare and contrast and you should do fine